/*
task：kmp算法解决lg8085
author : 李智铭 3022206093
*/
#include <iostream>
#include <algorithm>
#include <string>
#include <unordered_map>

using namespace std;

const int N = 1e6 + 1;  // 定义常数 N，表示字符串数组的最大长度

// 计算每个字符串元素上次出现的位置，存储在前缀数组 pre 中
// str[]: 输入字符串数组
// pre[]: 前缀数组，记录每个元素上次出现的位置
// len: 输入字符串的长度
void Preflex(string str[], int pre[], int len) {
    unordered_map<string, int> last_pos;  // 用哈希表记录字符串的上一次出现位置
    for (int i = 1; i <= len; i++) {
        pre[i] = last_pos[str[i]];  // 更新当前元素的上次出现位置
        last_pos[str[i]] = i;       // 更新哈希表中的当前元素位置
    }
}

// 构建失配数组 sp_len，用于 KMP 模式匹配中的回退
// preB[]: 模式串的前缀数组
// lenB: 模式串的长度
// len[]: 失配数组
void len(int preB[], int lenB, int sp_len[]) {
    int i = 2;
    int j = 1;

    while (i <= lenB) {
        // 检查前缀和后缀是否匹配，如果匹配则更新 sp_len 值
        if (i - preB[i] == j - preB[j] || !preB[j] && preB[i] <= i - j) {
            sp_len[i++] = j++;
        } else if (j > 0) {
            j = sp_len[j - 1] + 1; 
        } else {
            i++;
        }
    }
}

// 实现 KMP 算法，在主串中查找模式串的位置
// preA[]: 主串的前缀数组
// preB[]: 模式串的前缀数组
// sp_len[]: 模式串的失配数组
// lenA: 主串的长度
// lenB: 模式串的长度
// 返回值: 如果找到匹配，返回匹配起始位置的索引；否则返回 -1
int kmp(int preA[], int preB[], int sp_len[], int lenA, int lenB) {
    int i = 1, j = 1;

    while (i <= lenA) {
        // 检查当前字符是否匹配
        if (i - preA[i] == j - preB[j] || !preB[j] && preA[i] <= i - j) {
            i++, j++;
        } else if (j > 1) {
            j = sp_len[j - 1] + 1;
        } else {
            i++;
        }

        // 如果 j 超出模式串长度，则匹配完成，返回匹配起始位置
        if (j > lenB) {
            return i - lenB;
        }
    }

    return -1;  // 若没有找到匹配，返回 -1
}

int main() {
    string A[N], B[N];  // 存储主串和模式串的字符串数组
    int lenA = 0;       // 主串的实际长度
    int lenB = 0;       // 模式串的实际长度

    string s;
    // 输入主串，直到输入 "$" 为止
    while (cin >> s && s != "$") A[++lenA] = s;
    // 输入模式串，直到输入 "$" 为止
    while (cin >> s && s != "$") B[++lenB] = s;

    int preA[N] = {};   // 主串的前缀数组
    int preB[N] = {};   // 模式串的前缀数组
    int sp_len[N] = {}; // 模式串的失配数组

    Preflex(A, preA, lenA); // 构建主串的前缀数组
    Preflex(B, preB, lenB); // 构建模式串的前缀数组

    len(preB, lenB, sp_len); // 构建模式串的失配数组

    // 调用 KMP 算法并输出匹配结果
    cout << kmp(preA, preB, sp_len, lenA, lenB) << endl;
    return 0;
}
